﻿/*
*************************************************************************

 Le logiciel de gestion d'EPN

 @project OpenEPN.
 @version 0.1
 @legals  (c) 2008 Damien Maillard, Sébastien Reinders. 
 Needed Components : GTK-Sharp 2.8. 
 Licensed under GPL v2.

 @author  Damien Maillard <damien.maillard@openepn.be>
 @author  Sébastien Reinders <sebastien.reinders@openepn.be>
 @author  Didier Piette <didier.piette@openepn.be>
 @author  Nicolas Karras <nicolas.karras@openepn.be>
 @author  Julien Poulin <julien.poulin@openepn.be>
 @since   2008.02.08
 @latest  

 This program is free software; you can 
 redistribute it and/or modify it under
 the terms of the GNU General Public License as 
 published by the Free Software
 Foundation; either version 2 of the License, or 
 (at your option) any later version.

 This program is distributed in the hope that it 
 will be useful, but WITHOUT ANY WARRANTY; without even 
 the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE. See the GNU General 
 Public License for more details.

 You should have received a copy of the GNU General 
 Public License along with this program; if not, 
 write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA.
 
 * 
 * Conventions de nommage pour les variables locales :
 * m_ : pour les variables membres d'une méthode;
 * g_ : pour les variables membres d'une classe ;
 * c_ : pour les constantes;
 * s_ : pour les variables statiques;
 * e_ : pour les énumérations;
 * a_ : pour les Array et ArrayList;
 *  _ : pour les paramètres passés aux méthodes
 * T_ : T majuscule pour les Threads
 * E_ : E majuscule pour les événements
 * 
 
*************************************************************************
*/

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using BU.NetgestClient;
using OpenEPNClient;
using SystRestrClient;
using GI.BackgrndClient;

namespace OpenEPNClient
{
    #region "Délégués"

    /// <summary>
    /// 
    /// </summary>
    public delegate void CloseFormeInfo();

    #endregion

    /// <summary>
    /// Classe de démarrage de l'application
    /// </summary>
    static class Program
    {
        #region "Déclarations"

        /// <summary>
        /// Variable statique pour l'icône de la barre des tâches
        /// </summary>
        private static NotifyIcon s_icn;

        /// <summary>
        /// Variable statique qui va implémenter les contrôles visuels de l'application
        /// </summary>
        private static Controls s_Controls;

        /// <summary>
        /// Variable statique pour le menu contextuel de l'icône de la barre des tâches
        /// </summary>
        private static ContextMenuStrip s_TrayContextMenu;

        //_NK_Début
        /// <summary>
        /// Variable statique pour la gestion des restrictions clavier
        /// </summary>
        public static KBHookProvider prov;
        //_NK_Fin

        #endregion

        #region "Propriétés"

        //Pas de propriétés

        #endregion

        #region "Implémentations"

        #region "Méthodes privées"

        //Pas de méthodes privées

        #endregion

        #region "Méthodes publiques"

        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
        
        public static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            //_NK_Début
            prov = new KBHookProvider();
            prov.KeyDown += new EventHandler<KeyHookEventArgs>(prov_KeyDown);
            prov.KeyUp += new EventHandler<KeyHookEventArgs>(prov_KeyUp);
            prov.Enabled = true;
            prov.Block = true;
            //_NK_Fin

            s_icn = new NotifyIcon();         
            
            s_icn.Visible = true;
            s_icn.Icon = new System.Drawing.Icon(Application.StartupPath + "\\img\\logo_openepn16.ico");
            affectMenu();

            s_Controls = new Controls();

            fen_Login m_loginForm = new fen_Login(s_Controls);

            s_Controls.Connect();

            Application.Run();
        }

        //_NK_Début
        /// <summary>
        /// Méthode interceptant la pression d'une touche du clavier (touche enfoncée)
        /// </summary>
        /// <param name="sender">Pression de la touche</param>
        /// <param name="e">Evénement</param>
        public static void prov_KeyDown(object sender, KeyHookEventArgs e)
        {
            bool etat = false;

            // Combinaisons de touches Alt+F4 : false => autorise, true => empêche
            if (GI.BackgrndClient.Param.AltF4Restriction)
                if ((e.KeyCode.ToString().Equals("F4")) && (e.LeftAlt == true))
                    etat = true;
            // Combinaisons de touches Alt+Tab : false => autorise, true => empêche
            //if (prov.altTab == true)
            if (GI.BackgrndClient.Param.AltTabRestriction)
                if ((e.KeyCode.ToString().Equals("Tab")) && ((e.LeftAlt == true) || (e.RightAlt == true)))
                    etat = true;
            // Combinaisons de touches Ctrl+Tab : false => autorise, true => empêche
            if (GI.BackgrndClient.Param.CtrlTabRestriction)
                if ((e.KeyCode.ToString().Equals("Tab")) && ((e.LeftCtrl == true) || (e.RightCtrl == true)))
                    etat = true;
            // Touche Alt Escape : false => autorise, true => empêche
            if (GI.BackgrndClient.Param.AltEscRestriction)
                if (((e.LeftAlt == true) || (e.RightAlt == true)) && e.KeyCode.ToString().Equals("Escape"))
                    etat = true;
            // Touche Ctrl Escape : false => autorise, true => empêche
            if (GI.BackgrndClient.Param.CtrlEscRestriction)
                if (((e.LeftCtrl == true) || (e.RightCtrl == true)) && e.KeyCode.ToString().Equals("Escape"))
                    etat = true;
            // Touches Windows : false => autorise, true => empêche
            if (GI.BackgrndClient.Param.WindowsRestriction)
                if ((e.LeftWin == true) || (e.RightWin == true))
                    etat = true;
            prov.Block = etat;
        }

        /// <summary>
        /// Méthode interceptant la pression d'une touche du clavier (touche relachée)
        /// </summary>
        /// <param name="sender">relachement de la touche</param>
        /// <param name="e">Evénement</param>
        public static void prov_KeyUp(object sender, KeyHookEventArgs e)
        {
            prov.Block = false;
        }
        //_NK_Fin

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "fermeture de session" d'un utilisateur ou administrateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void disconnectStripMenu_Click(object sender, EventArgs e)
        {
            s_Controls.Disconnect();
            s_Controls.stopDecompte();  //ATTENTION : ICI, IL FAUDRA VERIFIER EN ADMINISTRATEUR SI CA NE BUG PAS!!!!!
            //prévoir de fermer les autres fenêtres
            //prévoir de stopper des processus utilisateurs
            s_Controls.CloseFenInfo();
        }

        //-------------------------------------
        //---- Menu pour l'administrateur -----
        //-------------------------------------

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "paramètre" du menu administrateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void settingsStripMenu_Click(object sender, EventArgs e)
        {
            //Affichage de la fenêtre des paramètres

            OpenEPNClient.fen_Param formeParam = new fen_Param(s_Controls);
            formeParam.Show();
        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "fermer" du menu administrateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void closeApplStripMenu_Click(object sender, EventArgs e)
        {
            //Fermeture du programme

            //SystRestrClient.RestrictTaslMgr.EnableCTRLALTDEL();
            //RestrictKeys restrictionClavier = new RestrictKeys();
            //restrictionClavier.dechargement();
            GI.BackgrndClient.ConnectionManager.deconnexionTcp();
            GI.BackgrndClient.Login.majtextarea("Fermeture de la connexion au serveur et arrêt de l'application");
            s_icn.Visible = false;

            /*notification de la fin de la connexion de l'utilisateur */
            s_Controls.stopDecompte();
            Application.Exit();    
        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "fermer la session" du menu administrateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void closeWinStripMenu_Click(object sender, EventArgs e)
        {
            //Fermeture de la session Windows : le paramètre à 0 pour fermer la session
            s_Controls.ShutDownComputer("0");
        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "arreter l'ordinateur" du menu administrateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void shutPcStripMenu_Click(object sender, EventArgs e)
        {
            //Eteindre l'ordinateur : le paramètre à 1 pour eteindre l'ordinateur
            s_Controls.ShutDownComputer("1");
        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "redémarrer l'ordinateur" du menu administrateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void restartPcStripMenu_Click(object sender, EventArgs e)
        {
            //redémarrer l'ordinateur : le paramètre à 2 pour redémarrer l'ordinateur
            s_Controls.ShutDownComputer("2");
        }

        //-------------------------------------
        //------ Menu pour l'utilisateur ------
        //-------------------------------------
        
        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "information" du menu utilisateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void InfoStripMenu_Click(object sender, EventArgs e)
        {
            //affichage des infos de l'utilisateur

            fen_Info formeInfo = new fen_Info(s_Controls);
            formeInfo.Show();
        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "blocage de session" du menu utilisateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void blockSessionStripMenu_Click(object sender, EventArgs e)
        {
            //bloque la session utilisateur

        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "changement de mot de passe" du menu utilisateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void changeLoginPassStripMenu_Click(object sender, EventArgs e)
        {
            //modification du login ou du mot de passe

        }

        /// <summary>
        /// Méthode agissant sur l'appel du point de menu "ouvrir le chat" du menu utilisateur
        /// </summary>
        /// <param name="sender">Click de bouton sur un point de menu</param>
        /// <param name="e">Evénement</param>
        public static void openChatStripMenu_Click(object sender, EventArgs e)
        {
            //ouvrir le chat

        }
        
        /// <summary>
        /// Méthode d'affectation du menu à l'icône de la barrre des tâches
        /// </summary>
        public static void affectMenu()
        {
            s_TrayContextMenu = DefineContextMenu.setContextMenu();
            s_icn.ContextMenuStrip = s_TrayContextMenu;
        }

        #endregion

        #endregion
    }
}